sort command

`sort` - sort lines of text files

The sort command in Linux is a versatile utility used to sort lines in text files or input. It’s great for organizing lists, logs, or data alphabetically, numerically, or by other criteria.

Usage: sort [OPTION]... [FILE]...

OPTION: Flags which enhances the diff abilities.
FILE: The file(s) to sort (optional; reads from input if omitted).

Examples

Basic Sorting

By default, sort orders lines alphabetically (lexicographically) and outputs to the terminal.
```
$ echo -e "banana\napple\ncherry" | sort
```
- Output:
```
apple
banana
cherry
```
With a File:
```
$ sort fruits.txt
```
- Sorts lines in fruits.txt and prints them.
Writing to a File

Use -o to save the sorted output to a file (can overwrite the input file).
```
$ sort fruits.txt -o fruits_sorted.txt
```
- Creates or overwrites fruits_sorted.txt with sorted lines.
Overwrite Original:
```
$ sort fruits.txt -o fruits.txt
```
- Sorts fruits.txt in place.
Numeric Sorting

Use -n to sort numerically instead of alphabetically.
```
$ echo -e "10\n2\n100" | sort -n
```
- Output:
```
2
10
100
```
- Without -n, it would sort as 10, 100, 2 (lexicographic order).
Reverse Order

Use -r to sort in descending order.
```
$ sort -r fruits.txt
```
- Output: cherry\nbanana\napple.
With Numbers:
```
$ echo -e "10\n2\n100" | sort -nr
```
- Output: 100\n10\n2.
Removing Duplicates

Use -u (unique) to remove duplicate lines after sorting.
```
$ echo -e "apple\nbanana\napple" | sort -u
```
- Output:
```
apple
banana
```
Sorting by Field

Use -k to sort by a specific field (fields are separated by whitespace by default).
```
$ echo -e "bob 30\nalice 25\nbob 15" | sort -k 2 -n
```
- Output:
```
bob 15
alice 25
bob 30
```
- -k 2: Sort by the second field (numbers).
- -n: Numeric sort.
Custom Field Separator

Use -t to specify a delimiter other than whitespace.
```
$ echo -e "apple:10\nbanana:5\ncherry:15" | sort -t ":" -k 2 -n
```
- Output:
```
banana:5
apple:10
cherry:15
```
- -t ":": Use : as the field separator.
- -k 2 -n: Sort by the second field numerically.

Ignoring Case

Use -f to sort case-insensitively.

echo -e "Apple\nbanana\nCherry" | sort -f

Output:
```
Apple
banana
Cherry
```

To get help related to the `sort` command use `--help` option

$ sort --help
Usage: sort [OPTION]... [FILE]...
  or:  sort [OPTION]... --files0-from=F
Write sorted concatenation of all FILE(s) to standard output.

With no FILE, or when FILE is -, read standard input.

Mandatory arguments to long options are mandatory for short options too.
Ordering options:

  -b, --ignore-leading-blanks  ignore leading blanks
  -d, --dictionary-order      consider only blanks and alphanumeric characters
  -f, --ignore-case           fold lower case to upper case characters
  -g, --general-numeric-sort  compare according to general numerical value
  -i, --ignore-nonprinting    consider only printable characters
  -M, --month-sort            compare (unknown) < 'JAN' < ... < 'DEC'
  -h, --human-numeric-sort    compare human readable numbers (e.g., 2K 1G)
  -n, --numeric-sort          compare according to string numerical value
  -R, --random-sort           shuffle, but group identical keys.  See shuf(1)
      --random-source=FILE    get random bytes from FILE
  -r, --reverse               reverse the result of comparisons
      --sort=WORD             sort according to WORD:
                                general-numeric -g, human-numeric -h, month -M,
                                numeric -n, random -R, version -V
  -V, --version-sort          natural sort of (version) numbers within text
  Other options:

      --batch-size=NMERGE   merge at most NMERGE inputs at once;
                            for more use temp files
  -c, --check, --check=diagnose-first  check for sorted input; do not sort
  -C, --check=quiet, --check=silent  like -c, but do not report first bad line
      --compress-program=PROG  compress temporaries with PROG;
                              decompress them with PROG -d
      --debug               annotate the part of the line used to sort,
                              and warn about questionable usage to stderr
      --files0-from=F       read input from the files specified by
                            NUL-terminated names in file F;
                            If F is - then read names from standard input
  -k, --key=KEYDEF          sort via a key; KEYDEF gives location and type
  -m, --merge               merge already sorted files; do not sort
  -o, --output=FILE         write result to FILE instead of standard output
  -s, --stable              stabilize sort by disabling last-resort comparison
  -S, --buffer-size=SIZE    use SIZE for main memory buffer
  -t, --field-separator=SEP  use SEP instead of non-blank to blank transition
  -T, --temporary-directory=DIR  use DIR for temporaries, not $TMPDIR or /tmp;
                              multiple options specify multiple directories
      --parallel=N          change the number of sorts run concurrently to N
  -u, --unique              with -c, check for strict ordering;
                              without -c, output only the first of an equal run
  -z, --zero-terminated     line delimiter is NUL, not newline
      --help     display this help and exit
      --version  output version information and exit

KEYDEF is F[.C][OPTS][,F[.C][OPTS]] for start and stop position, where F is a
field number and C a character position in the field; both are origin 1, and
the stop position defaults to the line's end.  If neither -t nor -b is in
effect, characters in a field are counted from the beginning of the preceding
whitespace.  OPTS is one or more single-letter ordering options [bdfgiMhnRrV],
which override global ordering options for that key.  If no key is given, use
the entire line as the key.  Use --debug to diagnose incorrect key usage.

SIZE may be followed by the following multiplicative suffixes:
% 1% of memory, b 1, K 1024 (default), and so on for M, G, T, P, E, Z, Y.

*** WARNING ***
The locale specified by the environment affects sort order.
Set LC_ALL=C to get the traditional sort order that uses
native byte values.

sort - sort lines of text files​

Examples​

To get help related to the sort command use --help option​

`sort` - sort lines of text files

Examples

To get help related to the `sort` command use `--help` option